/* $$$ JS file: nDynamic/nDynamic.js: */
/**
 * Dynamize object.
 * Add new features to object, depending on loaded nLibraries (nAction, nListener).
 * @author : Nickesh (nickesh.pl[at]gmail.com).
 * @copyright : 2006-2009 Nickesh
 * @date: 2009.07.18
 */
function nDynamic(obj) {
	obj.nName = 'nDynamic';

	if (window.nAction) {
		obj.motion = function(options) {
			var motionAction = new nAction({
				obj: obj,
				beforeActivate:function(end) {
					if (end != undefined) {
						this.end = end;
					}
					this.start = this.n;
					this.detectDirection();
				},
				onLoop:function() {
					this.decelerate();
				},
				onEndDetection:function() {
					if (this.isEnd()) {
						this.n = this.end;
						this.deactivate();
					}
				},
				onInitialize: ((options.onInitialize)? options.onInitialize : null)
				//onActivate
				//onUpdate
				//onDeactivate
			});
			
			motionAction.setOptions(options);
			return motionAction;
		}
	}
	
	if (window.nListener) {
		obj.point = function(options) {
			var newListener = new nListener({
				obj: obj,
				start: {x: 0, y: 0},
				n: {x: 0, y: 0},
				startScreen: null,
				
				// onInitialize
				beforeActivate:function() {
					this.startScreen = {x: this.event.screenX, y: this.event.screenY};
					nConfig.preventSelection();
				},
				// onActivate
				onLoop:function() {
					this.captureRelativeXY();
				},
				captureRelativeXY:function() {
					this.n.x = this.relativeX();
					this.n.y = this.relativeY();
				},
				relativeX:function() {
					return this.start.x + this.distanceX();
				},
				relativeY:function() {
					return this.start.y + this.distanceY();
				},
				distanceX:function() {
					return this.event.screenX - this.startScreen.x;
				},
				distanceY:function() {
					return this.event.screenY - this.startScreen.y;
				},
				limit:function(n, min, max) {
					if (n < min) return min;
					if (n > max) return max;
					return n;
				},
				// onUpdate
				// onDeactivate
				afterDeactivate:function() {
					this.start = {x: this.n.x, y: this.n.y};
					this.startScreen = null;
				}
			});
			newListener.setOptions(options);
			return newListener;
		}
	}


	// Styles in JS (not CSS) format (camelized, without dashes).
	obj.css = function(styles) {
		if (styles) {
			for (var i in styles) {
				if (i == 'opacity') {
//					this.style[i] = styles[i];
					this.cssOpacity(styles[i]);
				} else if (i == 'float') {
					this.cssFloat(styles[i]);
				} else {
					this.style[i] = styles[i];
				}
			}
		}
	}
	
	
	// realCss();
	// Styles in CSS (not JS) format (not camelized, with dashes).
	// 
	// Odczytyje wartosc stylu CSS z elementu nie modyfikowanego jeszcze JavaScriptem.
	// @param strCssRule : Nazwa stylu zapisana zgodnie z wzorem dla CSS (myslniki zamiast camelize'ow)
	if (document.defaultView && document.defaultView.getComputedStyle) {
		// Wersja dla normalnych przegladarek.
		obj.realCss = function(strCssRule) {
			return document.defaultView.getComputedStyle(obj, '').getPropertyValue(strCssRule);
		}
	} else if (document.body.currentStyle) {
		// Wersja dla IE.
		obj.realCss = function(strCssRule) {
			strCssRule = strCssRule.replace(/\-(\w)/g, function (strMatch, p1) {
				return p1.toUpperCase();
			});
			return obj.currentStyle[strCssRule];
		}
	}
	
	
	obj.realCssNum = function(strCssRule) {
		var number = parseFloat(obj.realCss(strCssRule));
		if (isNaN(number)) {
			return 0;
		}
		return parseFloat(number);
	}
	
	
	obj.realWidth = function() {
		return	  obj.offsetWidth
//				- obj.realCssNum('margin-left')
//				- obj.realCssNum('margin-right')
				- obj.realCssNum('padding-left')
				- obj.realCssNum('padding-right')
				- obj.realCssNum('border-left-width')
				- obj.realCssNum('border-right-width');
	}
	
	
	obj.realHeight = function() {
		return	  obj.offsetHeight
//				- obj.realCssNum('margin-top')
//				- obj.realCssNum('margin-bottom')
				- obj.realCssNum('padding-top')
				- obj.realCssNum('padding-bottom')
				- obj.realCssNum('border-top-width')
				- obj.realCssNum('border-bottom-width');
	}
	
	obj.realBackgroundPosition = function() {
		var p = obj.realCss('background-position');
		if (p == undefined) {
			p = obj.realCss('background-position-x') + ' ' + obj.realCss('background-position-y');
		}
		return p;
	}
	
	
	obj.addClass = function(className) {
		this.className += ' ' + className;
	}
	
	
	obj.dropClass = function(className) {
		this.className = this.className.replace(new RegExp('\\b' + className + '\\b', 'g'), '');
	}
	
	
	obj.hasClass = function(className) {
		return new RegExp('\\b' + className + '\\b', 'g').test(this.className);
	}
	
	
	if (nConfig.isIE) {
		obj.cssOpacity = function(value) {
			this.style.filter = 'alpha(opacity=' + value + ')';
		}
	} else {
		obj.cssOpacity = function(value) {
			this.style.opacity = value / 100;
		}
	}
	
		
	obj.cssFloat = function(value) {
		this.style.cssFloat = value;
	}

	
	obj.config = {};
	
	obj.configure = function(config) {
		for (var i in config) {
			this.config[i] = config[i];
		}
	}
}


function nConfig() {
//	alert(navigator.userAgent);
	this.isOpera = (navigator.userAgent.indexOf('Opera') != -1);
	if (!this.isOpera && navigator.userAgent.indexOf('MSIE') != -1) {
		this.isIE = parseFloat(navigator.userAgent.replace(/.*MSIE\s*([0-9]+(\.[0-9]+)?).*/, '$1'));
	} else {
		this.isIE = false;
	}

// @todo ...
//	this.init = function() {}
//	this.init();
	this.include = function(file) {
		var script  = document.createElement('script');
		script.src  = file;
		script.type = 'text/javascript';
		script.defer = true;

		document.getElementsByTagName('head').item(0).appendChild(script);
	}
	
	this.preventSelection = function() {
		document.body.focus();
		document.onselectstart = function() { return false; }
	}
	
	this.addEvent = function(node, type, callback) {
		if (node.addEventListener) {
			node.addEventListener(type, callback, false);
		} else {
			node.attachEvent('on' + type, callback);
		}
	}
	
	this.dropEvent = function(node, type, callback) {
		if (node.removeEventListener) {
			node.removeEventListener(type, callback, false);
		} else {
			node.detachEvent('on' + type, callback);
		}
	}
	
	// @param code : string or function
	this.onLoad = function(func) {
		if (typeof(func) == 'function') {
			this.addEvent(window, 'load', func);
		}
	}
}

var nConfig = new nConfig();



// ========= "Dolar functions": ============

if (!window.$) {
	window.$ = function(id) {
		return document.getElementById(id);
	}
}


/**
 * Wyszukuje elementy o podanej klasie.
 * Jesli podano tag, wyszuka tylko elementy tych tagow.
 * Jesli podano node, bedzie szukac tylko wewnatrz tego obiektu.
 */
if (!window.$$) {
	window.$$ = function(className, tag, node) {
		if (!node) {
			node = document;
		} else if (typeof(node) != 'object') {
			node = $(node);
		}
		
		if (tag == null)
			tag = '*';
		
		var i, j = 0;
		var classElements = new Array;
		var allElements = node.getElementsByTagName(tag);
		
		for (i = 0; i < allElements.length; i++) {
			if (!className || allElements[i].className.match(new RegExp('\\b' + className + '\\b'))) {
				classElements[j] = allElements[i];
				j++;
			}
		}
		
		return classElements;
	}
}


/**
 * Wyszukuje bezposrednie elementy o podanej klasie.
 * Jesli podano tag, wyszuka tylko elementy tych tagow.
 * Jesli podano node, bedzie szukac tylko wewnatrz tego obiektu.
 * @todo : naprawic ta funkcje - teraz cos jest nie tak z rozpoznawaniem bezposrednich potomkow node'a. Interpretacja childNodes zalezy od przegladarki.
 */
if (!window.$$$) {
	window.$$$ = function(className, tag, node) {
		if (!node) {
			node = document;
		} else if (typeof(node) != 'object') {
			node = $(node);
		}
		
		if (!tag || tag == '*')
			tag = '';
			
		tag = tag.toLowerCase();
		
		var nodes = new Array;
		
		for (var i in node.childNodes) {
			if (nConfig.isOpera && node.childNodes[i].parentNode != node) {
				break;
			}
			
			if (node.childNodes[i].nodeType == 1) {
				if (!className || (node.childNodes[i].className && node.childNodes[i].className.match(new RegExp('\\b' + className + '\\b')))) {
					if (!tag || node.childNodes[i].tagName.toLowerCase() == tag) {
						nodes.push(node.childNodes[i]);
					}
				}
			}
		}

		return nodes;
	}
}

/**
 * nic nie robi
 */
function nev2006() {}
/* $$$ JS file: nDynamic/nDynamicAction.js: */
if (!window.nDynamic) alert('Require nDynamic library.');

/**
 * Callbacks order:
 * 		public		onInitialize
 * 		protected	beforeActivate
 * 		public		onActivate
 * 		public	{	onLoop
 *		protected	onEndDetection
 * 		public		onUpdate	}
 * 		public 		onDeactivate
 */
function nAction(options) {
	this.nName = 'nAction';

	this.setOptions = function(options) {
		if (options) {
			// Ustawianie konfiguracji:
			for (option in options) {
				this[option] = options[option];
			}
		}
	}
	
	this.activate = function(options) {
		nActionLoop.enqueueAction(this);
		if (this.beforeActivate) {
			this.beforeActivate(options); // @todo : sprawdzic, czy to moze byc przed enqueueAction i przeniesc
		}
		if (this.onActivate) {
			this.onActivate(options);
		}
		return this;
	}
	
	this.deactivate = function() {
		// @todo : dodac w tym miejscu beforeDeactivate();
		nActionLoop.dequeueAction(this);
		if (this.onDeactivate) {
			this.onDeactivate();
		}
		if (onThen) {
			onThen();
		}
		return this; // @todo : czy to potrzebne?
	}
	
	var onThen = null;
	this.then = function(func) {
		onThen = function() {
			func();
			onThen = null;
		}
	}
	
	this.run = function() {
		if (this.onLoop) {
			this.onLoop();
		}
		if (this.onEndDetection) {
			this.onEndDetection();
		}
		if (this.onUpdate) {
			this.onUpdate();
		}
	}
	
	this.beforeActivate = function() {
		this.detectDirection();
	}
	
	this.onEndDetection = function() {
		if (this.isEnd()) {
			this.deactivate();
		}
	}
	
	
	// konstruktor {
		// public
		this.start = 0;
		this.end = 10;
		this.factor = 0.1;
		// private
		this.direction = 1;
		this.n = this.start;
		
		this.setOptions(options);
		this.actionId = nActionLoop.registerActionId();
		
		if (typeof this.onInitialize == 'function') {
			this.onInitialize();
		}
	// }
	
	
	
	this.detectDirection = function() {
		this.direction = (this.start <= this.end) * 2 - 1;
	}

	
	this.isEnd = function() {
		return (this.n * this.direction >= this.end * this.direction);
	}
	
	
	/**
	 * Ruch jednostajnie opozniony.
	 * Wartosc zalezy od faktora i od dystantu.
	 */
	this.decelerate = function() {
		this.n += Math.ceil(this.direction * (this.end - this.n) * this.factor) * this.direction;
	}
	
	
	/**
	 * Ruch jednostajnie przyspieszony.
	 * Wartosc przyspiszenia zalezy tylko od faktora.
	 */
	this.accelerate = function() {
		this.n += (Math.ceil((this.n - this.start) * this.factor) || this.direction);
	}
	
	
	/**
	 * Ruch jednostajny.
	 * Predkosc zalezy tylko od factora.
	 */
	this.uniform = function() {
		this.n += (Math.ceil(this.factor * 100 * this.direction) || this.direction);
	}
	
	
	/**
	 * Ruch jednostajny.
	 * Predkosc zalezy od factora i od DYSTANSU. Im wiekszy dystans pomiedzy start i end, tym wieksza predkosc.
	 */
	this.distantional = function() {
		this.n += (Math.ceil(this.factor / 10 * (this.end - this.start)) || this.direction);
	}
	

	/**
	 * Ruch zalezny.
	 * Predkosc ruchu zalezy od predkosci ruchu akcji, od ktorej biezaca akcja jest zalezna.
	 * @todo : Dodac do wzoru "direction". Zoptymalizowac.
	 */
	this.depended = function(affectingAction) {
		this.n = Math.ceil((this.end - this.start) / (affectingAction.end - affectingAction.start) * (affectingAction.n - affectingAction.start)) + this.start || this.direction;
//		alert(((this.end - this.start)) + '/' + (affectingAction.end - affectingAction.start) + '*' +  (affectingAction.n - affectingAction.start) + '=' + this.n);
	}
	
	return this;
}


/**
 * Passive animation loop.
 *
 * ====== API: ======
 *
 * Public:
 * 		start([fps])			: Initialize and enable animations (if already started, method executes stop() before start()).
 * 		stop()				: Disable animations and clear actions queue.
 *
 * Protected:
 *		sleep()				: Suspend animations (faster than stop(); does not clear the queue).
 *		wake()				: Unsuspend animations (faster than start()).
 *		nName				: nDynamic object category.
 *
 * Private:
 *		registerActionId()
 *		enqueueAction(action)
 *		dequeueAction(action)
 * 		frame()
 */
function nActionLoop() {
	this.nName = 'nActionLoop';
	
	var frameRate = 25; // frames interval in miliseconds
	var actionAutoIncrement = 0;
	var queue = new Array;
	this.loop = null;


	// Rejestruje akcje = przydziela jej identyfikator, niezbedny do dalszej pracy z akcja.
	this.registerActionId = function() {
		return actionAutoIncrement++;
	}
	
	this.enqueueAction = function(action) {
		queue[action.actionId] = action;
		if (this.loop == null) this.wake();
	}
	
	this.dequeueAction = function(action) {
		queue[action.actionId] = null;
	}
	
	// Initialize loop.
	this.start = function(fps) {
		if (this.loop) {
			this.stop();
		}
		
		if (fps) {
			frameRate = Math.round(1000/fps);
		}
		
		this.wake();
	}

	// Wake up loop.
	this.wake = function() {
		this.loop =	setInterval(
			function() {
				nActionLoop.frame();
			},
			frameRate);
	}
	
	// Stop loop and clear queue.
	this.stop = function() {
		this.sleep();
		this.clearQueue();
	}
	
	// Asleep loop.
	this.sleep = function() {
		clearInterval(this.loop);
		this.loop = null;
	}
	
	this.clearQueue = function() {
		var queueLength = queue.length;
		for (var i in queue) {
			delete queue[i];
		}
	}
	

	// Execute all enqueued actions "frameRate" times per second.
	this.frame = function() {
		// @todo : zoptymalizowac przez uzycie listy zamiast tablicy akcji
		var amount = 0;
		for (var id in queue) {
			if (queue[id]) {
				queue[id].run();
				amount++;
			}
		}
		if (amount == 0) this.sleep();	// @todo : Czy w tym miejscu kolejka tez nie powinna byc czyszczona? (stop() zamiast sleep()).
	}
}

var nActionLoop = new nActionLoop();
/* $$$ JS file: nDynamic/nDynamicMorpher.js: */
function nMorpher() {
	
	this.open = function(obj, options) {
		obj.blur();
		if (!this.isMorphable(obj)) {
			this.morphable(obj, options);
		}
		return obj.open();
	}
	
	this.close = function(obj, options) {
		obj.blur();
		if (!this.isMorphable(obj)) {
			this.morphable(obj, options);
		}
		return obj.close();
	}
	
	this.toggle = function(obj, options) {
		obj.blur();
		if (!this.isMorphable(obj)) {
			this.morphable(obj, options);
		}
		if (options && options.open !== undefined) {
			return obj.toggle(options.open);
		} else {
			return obj.toggle();
		}
	}
	
	this.isMorphable = function(obj) {
		if (obj.wrapper && obj.wrapper.nName == 'nMorpherWrapper') {
			return true;
		}
		return false;
	}
	
	
	/**
	 * @param object[optional] options : Available options:
	 *	- axis
	 *	- closedValue
	 *	- unit
	 *	- useDisplayNone
	 *	- beginOpen
	 *	- factor
	 *	- outerBorder
	 */
	this.morphable = function(obj, options) {
		nDynamic(obj);
		obj.nName = 'nMorphable';

		obj.configure({
			axis:				'height', // 'width' or 'height'
			closedValue:		0,
			unit:				'px',
			useDisplayNone:	(options && options.closedValue)? false : true,
			beginOpen:		(obj.realCss('display') == 'none')? false : true,
			factor:				0.2,
			outerBorder:		false
		});
		
		if (options) obj.configure(options);
		
		wrapper = document.createElement('div');
		obj.parentNode.insertBefore(wrapper, obj);
		wrapper.appendChild(obj);
		obj.wrapper = wrapper;
		
		nDynamic(obj.wrapper);
		obj.wrapper.nName = 'nMorpherWrapper';

		obj.originalCss = {};
		// Nadanie stylu wrapperowi, bazujac na stylach dotyczacych zewnetrznych wlasciwosci obj'ta.
		obj.originalCss.display = obj.realCss('display');
		obj.style.display = obj.workDisplay = (obj.originalCss.display == 'none') ? 'block' : obj.originalCss.display;
		
		obj.originalCss.width = obj.offsetWidth;
		obj.originalCss.height = obj.offsetHeight;
		obj.originalCss.position = obj.realCss('position');

		obj.wrapper.css({
			overflow:		'hidden',
			zIndex:		obj.realCss('z-index'),
			display:		obj.config.useDisplayNone ? obj.originalCss.display : obj.workDisplay,
			'float':			obj.realCss('float'),
			position:		obj.originalCss.position,//nConfig.isOpera && obj.originalCss.position == 'relative' ? 'static' : obj.originalCss.position,
			width:			obj.originalCss.width + obj.config.unit,
			height:			obj.originalCss.height + obj.config.unit,
			marginLeft:	obj.realCss('margin-left'),
			marginRight:	obj.realCss('margin-right'),
			marginTop:	obj.realCss('margin-top'),
			marginBottom:	obj.realCss('margin-bottom')
			
//			left:			obj.realCss('left'),
//			top:			obj.realCss('top')
		});
		
		if (!obj.config.beginOpen) obj.wrapper.style[obj.config.axis] = obj.config.closedValue + obj.config.unit;
		
		// Wyzerowanie zewnetrznych stylow obj'ta.
		obj.css({
			position:		'static',
			left:			0,
			top:			0,
			margin:		0,
			'float':			'none',
			display:		obj.workDisplay
		});
		
		if (obj.config.outerBorder) {
			obj.wrapper.css({
				borderLeftStyle:		obj.realCss('border-left-style'),
				borderRightStyle:		obj.realCss('border-right-style'),
				borderTopStyle:		obj.realCss('border-top-style'),
				borderBottomStyle:	obj.realCss('border-bottom-style'),
				
				borderLeftWidth:		obj.realCss('border-left-width'),
				borderRightWidth:		obj.realCss('border-right-width'),
				borderTopWidth:		obj.realCss('border-top-width'),
				borderBottomWidth:	obj.realCss('border-bottom-width'),
				
				borderLeftColor:		obj.realCss('border-left-style-color'),
				borderRightColor:		obj.realCss('border-right-color'),
				borderTopColor:		obj.realCss('border-top-color'),
				borderBottomColor:	obj.realCss('border-bottom-color')
			});
			obj.style.border = 0;
		}
		
		// @todo : Ponizszy warunek powinien wykrywac, czy w arkuszu stylow podano top i left
		if (!nConfig.isOpera || obj.style.position != 'relative') {
//				alert(obj.realCssNum('top') + ' = ' + obj.offsetTop + ' = ' + obj.style.top);
			obj.wrapper.style.left = obj.realCss('left');
			obj.wrapper.style.top = obj.realCss('top');
		}


		obj.wrapper.buildSlider = function(axis) {
			if (!obj.wrapper.slider) obj.wrapper.slider = {};
			
			obj.wrapper.slider[axis] = obj.wrapper.motion({
				factor:		obj.config.factor,
				n:			obj.config.beginOpen? obj.originalCss[axis] : obj.config.closedValue,
				opened:	obj.config.beginOpen,

				onInitialize:function() {
					obj.workDisplay = this.obj.style.display = 'block';
				},
				onUpdate:function() {
					this.obj.style[axis] = this.n + obj.config.unit;
				},
				open:function() {
					this.activate(obj.originalCss[axis]);
					this.opened = true;
				},
				close:function() {
					this.activate(obj.config.closedValue);
					this.opened = false;
				},
				/**
				 * @param open [optional]: Force open on true or force close on false.
				 */
				toggle:function(open) {
					if ((open != undefined)? open : !this.opened) {
						this.open();
					} else {
						this.close();
					}
				}
			});
		
			if (obj.config.useDisplayNone) {
				obj.wrapper.slider[axis].onActivate = function() {
					if (!this.opened) {
						this.obj.style.display = 'block';
					}
				}
				
				obj.wrapper.slider[axis].onDeactivate = function() {
					if (!this.opened) {
						this.obj.style.display = 'none';
					}
				}
			}
		}
		
		obj.wrapper.buildSlider(obj.config.axis);

		obj.open = function() {
			obj.wrapper.slider[obj.config.axis].open();
			return false;
		}

		obj.close = function() {
			obj.wrapper.slider[obj.config.axis].close();
			return false;
		}

		obj.toggle = function(open) {
			obj.wrapper.slider[obj.config.axis].toggle(open);
			return false;
		}
	}
}


var nMorpher = new nMorpher();
/* $$$ JS file: nDynamic/nTree.js: */
function nTree(obj) {
//	nDynamic(obj);
	obj.nName = 'nTree';
	
	obj.config = {
		factor: 0.5,
		beginOpen: true,
		closedValue: 0,
		unit: 'px',
		branchTag: 'menu',
		nodeTag: 'li',
		activatorOpen: 'activatorOpen',
		activatorClosed: 'activatorClosed',
		activatorEmpty: 'activatorEmpty'
	}
	
	
	obj.activatorOpen = 'activatorOpen';
	obj.activatorClosed = 'activatorClosed';
	
	
	obj.nNode = function(node) {

		node.activator = $$('activator', 'span', node)[0];
		node.branch = $$('', obj.config.branchTag, node)[0];
		
		if (node.branch) {
			obj.nBranch(node.branch);
			
			node.toggle = function() {
				if (node.branch.hidden()) {
					node.branch.show();
					node.activator.className = obj.activatorOpen;
				} else {
					node.branch.hide();
					node.activator.className = obj.activatorClosed;
				}
			}
			
			node.activator.onclick = node.toggle;
		}
	}
	
	
	obj.nBranch = function(branch) {
		nDynamic(branch);
		branch.nName = 'nBranch';
		
		obj.analyse(branch);
		
		branch.style.display = branch.realCss('display');
		
		branch.show = function() {
			branch.style.display = 'block';
		}
		
		branch.hide = function() {
			branch.style.display = 'none';
		}
		
		branch.hidden = function() {
			if (branch.style.display == 'none') {
				return true;
			}
			return false;
		}
	}
	
	
	obj.analyse = function(branch) {
		branch.nodes = $$$('', obj.config.nodeTag, branch);
		for (i in branch.nodes) {
			obj.nNode(branch.nodes[i]);
		}
	}
		
	obj.analyse(obj);
}
/* $$$ JS file: nDynamic/nInputDescribed.js: */
/**
 * @param obj : Existing DOM object (form element with declared property: 'value').
 * @param config : Configuration options:
 						- emptyClassName : Name of CSS class containing styles to apply, when object value is empty.
 */
function nInputDescribed(obj, config) {
	nDynamic(obj);
	obj.nName = 'nInputDescribed';
	
	obj.configure({emptyClassName: 'nInputDescribedEmpty'});
	obj.configure(config);
	obj.addClass('nInputDescribed');

	nConfig.addEvent(obj, 'blur', function() {
		if (obj.value != '') {
			obj.dropClass(obj.config.emptyClassName);
		} else {
			obj.addClass(obj.config.emptyClassName);
		}
	});
	
	nConfig.addEvent(obj, 'focus', function() {
		obj.dropClass(obj.config.emptyClassName);
	});
	
	nConfig.addEvent(window, 'load', function() {
		if (!obj.value) {
			obj.addClass(obj.config.emptyClassName);
		}
	});
}
/* $$$ JS file: nDynamic/nArrow.js: */
if (!window.nDynamic) alert('Require nDynamic library.');

function nArrow(obj, options) {

	nDynamic(obj);
	obj.nName = 'nArrow';

	obj.configure({
		width:					obj.realWidth(),
		align:					'left',
		backgroundPosition:	obj.realBackgroundPosition().split(/\s/),
		onclick:				null
	});
	obj.configure(options);

	
	obj.slider = obj.motion({
		factor: 0.2,
		align: ((obj.config.align == 'left')? -1 : 1),
		onUpdate:function() {
			this.obj.style.backgroundPosition = (this.align * this.n) + 'px ' + obj.config.backgroundPosition[1].replace('0px', '0');
		},
		over:function() {
			this.activate(this.obj.config.width);
		},
		out:function() {
			if (this.isEnd()) {
				this.n = 0;
				this.activate(0);
			} else {
				this.onDeactivate = function() {
					this.n = 0;
					this.activate(0);
					this.onDeactivate = null;
				}
			}
			
		},
		click:function() {
			if (this.isEnd()) {
				this.n = this.obj.config.width;
				this.activate(2 * this.obj.config.width);
			} else {
				this.end += this.obj.config.width;
			}
		}
	});
	
	obj.enable = function() {
		obj.style.visibility = 'visible';
	}
	
	obj.disable = function() {
		obj.style.visibility = 'hidden';
	}	
	
	nConfig.addEvent(obj, 'mouseover', function() {
		obj.slider.over();
	});
	
	nConfig.addEvent(obj, 'click', function() {
		obj.slider.click();
		nConfig.preventSelection();
	});
	
	if (typeof(obj.config.onclick) == 'function') {
		nConfig.addEvent(obj, 'click', obj.config.onclick);
	}
	
	nConfig.addEvent(obj, 'mouseout', function() {
		obj.slider.out();
	});
}
/* $$$ JS file: nDynamic/nImagesBar.js: */
if (!window.nArrow) alert('Require nArrow library.');

/**
 *
 * @param object $obj			: DOM object containing images.
 * @param object $options		: Configuration options:
 *		int $viewWidth		: Wanted width of pagesBar in pixels.
 *		int widthCorrection	: Additional pixel width for each element (margins, paddings, borders etc.)
 *		string imageClass	: CSS class of elements.
 *		string imageTag	: HTML tag of element.
 *		bool cyclic			: Tells if nextPage and prevPage methods will run cyclically.
 */
function nImagesBar(obj, options) {

	nDynamic(obj);
	obj.nName = 'nImagesBar';
	
	obj.configure({
		viewWidth: obj.parentNode.offsetWidth,
		widthCorrection: ((nConfig.isIE && nConfig.isIE < 7)? 15 : 0),
		imageClass: 'thumb',
		imageTag: 'a',
		cyclic: true,
		factor: 0.2,
		arrowNext: null,
		arrowNextOptions: {align: 'right'},
		arrowPrev: null,
		arrowPrevOptions: {align: 'left'}
	});
	
	obj.configure(options);
	
	obj.thumbsWidthSum = 0;
	obj.initialPosition = 0;
	obj.pages = [];

	obj.currentPage = 0;
	
	obj.init = function() {
		pos = 0;
		lastPagePosition = 0;
		last = false;
		 
		obj.thumbs = $$$(obj.config.imageClass, obj.config.imageTag, obj);
		for (i in obj.thumbs) {
			obj.thumbs[i].width = obj.thumbs[i].offsetWidth + obj.config.widthCorrection;
			obj.thumbsWidthSum += obj.thumbs[i].width;
			if (parseInt(obj.thumbsWidthSum / obj.config.viewWidth) > pos) {
				pos = parseInt(obj.thumbsWidthSum / obj.config.viewWidth);
				obj.pages[pos - 1] = (obj.config.viewWidth) - (obj.thumbsWidthSum - obj.thumbs[i].width);
				lastPagePosition = obj.thumbs[i].width;
			} else {
				lastPagePosition += obj.thumbs[i].width;
			}
		}
		
		if (obj.pages.length) {
			obj.pages[obj.pages.length] = obj.pages[pos - 1] - lastPagePosition;
		}
		
		if (obj.pages.length > 1) {
			obj.initialPosition = obj.pages[0];
		} else {
			obj.initialPosition = obj.config.viewWidth - obj.thumbsWidthSum;
		}
		
	
		obj.slider = obj.motion({
			//n: obj.initialPosition,
			factor: obj.config.factor,
			onUpdate:function() {
				this.obj.style.left = this.n + 'px';
			}
		});
		
		if (obj.config.arrowPrev && typeof(obj.config.arrowPrev) == 'object') {
			obj.config.arrowPrevOptions.onclick = function() {
				obj.prevPage();
				return false;
			}
			nArrow(obj.config.arrowPrev, obj.config.arrowPrevOptions);
		}
		
		if (obj.config.arrowNext && typeof(obj.config.arrowNext) == 'object') {
			obj.config.arrowNextOptions.onclick = function() {
				obj.nextPage();
				return false;
			}
			nArrow(obj.config.arrowNext, obj.config.arrowNextOptions);
		}
		
		obj.updateArrows();
	
		obj.slider.activate(obj.initialPosition);
		obj.css({
//			left: obj.initialPosition + 'px',
			visibility: 'visible'
		});
	}
	
	obj.goToPage = function(pageNumber) {
		obj.currentPage = pageNumber;
		obj.slider.activate(obj.pages[pageNumber]);
		obj.updateArrows();
	}
	
	obj.nextPage = function() {
		if (obj.pages[obj.currentPage + 1]) {
			obj.goToPage(obj.currentPage + 1);
		} else if (obj.config.cyclic) {
			obj.goToPage(0);
		}
	}
	
	obj.prevPage = function() {
		if (obj.pages[obj.currentPage - 1]) {
			obj.goToPage(obj.currentPage - 1);
		} else if (obj.config.cyclic) {
			if (obj.pages.length > 1) {
				obj.goToPage(obj.pages.length - 1);
			} else {
				obj.goToPage(0);
			}
		}
	}
	
	
	obj.updateArrows = function() {
		if (obj.pages.length) {
			if (!obj.config.cyclic) {
				if (obj.config.arrowPrev) {
					if (obj.currentPage == 0) {
						obj.config.arrowPrev.disable();
					} else {
						obj.config.arrowPrev.enable();
					}
				}
				if (obj.config.arrowNext) {
					if (obj.pages.length - 1 == obj.currentPage) {
						obj.config.arrowNext.disable();
					} else {
						obj.config.arrowNext.enable();
					}
				}
			} else {
				if (obj.config.arrowPrev) obj.config.arrowPrev.enable();
				if (obj.config.arrowNext) obj.config.arrowNext.enable();
			}
		}
	}
	
	
	obj.init();
}
/* $$$ JS file: nDynamic/nColumnsBar.js: */
if (!window.nArrow) alert('Require nArrow library.');

function nColumnsBar(obj, options) {
	nDynamic(obj);
	obj.nName = 'nColumnsBar';
	
	obj.configure({
		columnColumnClass:		'nColumn',
		wrapperWidth:				obj.realWidth(),
		gap:						30,
		cyclic:						0,
		columnsPerPage:			{1: 0, 2: 527}, // int or object {int columnsAmount: int minWrapperWidthToUseColumnsAmount, ...}
		scrollBy:					2,
		scrollFactor:				0.2,
		arrowNext: null,
		arrowNextOptions: {align: 'right'},
		arrowPrev: null,
		arrowPrevOptions: {align: 'left'}
	});
	
	obj.configure(options);

	obj.computeColumnsParts = function() {
		obj.config.wrapperWidth = obj.realWidth();

		if (typeof(obj.config.columnsPerPage) == 'object') {
			var z = -1;
			for (i in obj.config.columnsPerPage) {
				if (z == -1) z = i;
				if (obj.config.columnsPerPage[i] < obj.config.wrapperWidth && obj.config.columnsPerPage[i] > obj.config.columnsPerPage[z]) {
					z = i;
				}
			}
			obj.columnsPerPage = z;
		} else {
			obj.columnsPerPage = obj.config.columnsPerPage;
		}
		
		if (obj.config.scrollBy > obj.columnsPerPage) obj.config.scrollBy = obj.columnsPerPage;
	}
	

	obj.init = function() {
		var i;
		obj.style.overflow = 'hidden';

//		if (nConfig.isIE) {
			obj.style.width = obj.realWidth() + 'px';
//		}
		
		
		obj.computeColumnsParts();
		
		obj.column = $$(obj.config.columnColumnClass, 'div', obj);
		obj.columnsAmount = 0;
		
		for (i in obj.column) {
			nDynamic(obj.column[i]);
			obj.column[i].nName = 'nColumnsBar_column';
			obj.columnsAmount++;
		}
		
		for (i in obj.column) {
			obj.column[i].width = 0;
			with (obj.column[i]) {
				width =
					(obj.config.wrapperWidth / obj.columnsPerPage)
					- realCssNum('padding-left')
					- realCssNum('padding-right')
					- realCssNum('margin-left')
					- realCssNum('margin-right')
					- realCssNum('border-left')
					- realCssNum('border-right')
					- ((obj.columnsPerPage - 1) * obj.config.gap / obj.columnsPerPage);
					
				style.marginRight = obj.config.gap + 'px';
				style.width = width + 'px';
				style.display = 'block';
			}
		}

		obj.wrapper = document.createElement('div');
		nDynamic(obj.wrapper);
		obj.wrapper.width = 0;
		
		with (obj.wrapper) {
			addClass('nColumns');
			clearer = document.createElement('div');
			clearer.className = 'clear';
			appendChild(clearer);
			
			for (i in obj.column) {
				appendChild(obj.column[i]);
				width += obj.column[i].width + obj.config.gap;
			}

			style.width = width + 'px';
		}
		
		
		obj.wrapper.slider = obj.wrapper.motion({
			factor: obj.config.scrollFactor,
			amount: obj.columnsAmount,
			current: 0,
			onUpdate:function() {
				this.obj.style.marginLeft = (-1 * this.n) + 'px';
			},
			goTo:function(num) {
				if (this.amount > 1) {
					if (num < 0) {
						if (num > -1 * obj.config.scrollBy) {
							this.current = 0;
						} else if (obj.config.cyclic) {
							this.current = this.amount - obj.columnsPerPage;
						}
					} else if (num > this.amount - obj.columnsPerPage) {
//						alert(num + ', ' + this.current + ', ' + (this.current - obj.config.scrollBy));
						if (num < this.amount - obj.columnsPerPage + obj.config.scrollBy) {
							this.current = this.amount - obj.columnsPerPage; // last page
						} else if (obj.config.cyclic) {
							this.current = 0;
						}
					} else {
						this.current = num;
					}
					
					var scrollWidth = 0;
					var k, i = 0;
					for (k in obj.column) {
						if (i >= this.current) break;
						scrollWidth += obj.column[k].width + obj.config.gap;
						i++;
					}
					
					this.activate(scrollWidth);
					obj.updateArrows();
				}
			},
			next:function() {
				this.goTo(this.current + (1 * obj.config.scrollBy));
			},
			prev:function() {
				this.goTo(this.current - obj.config.scrollBy);
			},
			isLast:function() {
				if (this.current == this.amount - obj.columnsPerPage) {
					return true;
				}
				return false;
			}
		});
		
		obj.appendChild(obj.wrapper);
		
		obj.prev = function() {
			obj.wrapper.slider.prev();
			return false;
		}
		
		obj.next = function() {
			obj.wrapper.slider.next();
			return false;
		}
		
		obj.go = function(num) {
			obj.wrapper.slider.goTo(num);
			return false;
		}
		
		if (obj.config.arrowPrev && typeof(obj.config.arrowPrev) == 'object') {
			obj.config.arrowPrevOptions.onclick = function() {
				obj.prev();
				return false;
			}
			nArrow(obj.config.arrowPrev, obj.config.arrowPrevOptions);
		}

		if (obj.config.arrowNext && typeof(obj.config.arrowNext) == 'object') {
			obj.config.arrowNextOptions.onclick = function() {
				obj.next();
				return false;
			}
			nArrow(obj.config.arrowNext, obj.config.arrowNextOptions);
		}
		
		
		obj.updateArrows = function() {
			if (obj.columnsAmount > 1) {
				if (obj.config.arrowPrev) {
					if (obj.wrapper.slider.current == 0) {
						 obj.config.arrowPrev.disable();
					} else {
						 obj.config.arrowPrev.enable();
					}
				}
				if (obj.config.arrowNext) {
					if (obj.wrapper.slider.isLast()) {
						obj.config.arrowNext.disable();
					} else {
						obj.config.arrowNext.enable();
					}
				}
			}
		}
	}
	
	obj.updateWidths = function() {
		
		obj.computeColumnsParts();
		obj.wrapper.width = 0;
		
		var i;
		for (i in obj.column) {
			obj.column[i].width = 0;
			with (obj.column[i]) {
				width =
					(obj.config.wrapperWidth / obj.columnsPerPage)
					- realCssNum('padding-left')
					- realCssNum('padding-right')
					- realCssNum('margin-left')
					- realCssNum('margin-right')
					- realCssNum('border-left')
					- realCssNum('border-right')
					- ((obj.columnsPerPage - 1) * obj.config.gap / obj.columnsPerPage);
				
				obj.wrapper.width += width + obj.config.gap;
					
				style.marginRight = obj.config.gap + 'px';
				style.width = width + 'px';
			}
		}
		
		obj.wrapper.style.width = obj.wrapper.width + 'px';
	}
	
	obj.init();
	obj.updateArrows();
}
/* $$$ JS file: nDynamic/nDropMenu.js: */
function nDropMenu(obj) {
	if (obj.menu = $$('nDropMenu', 'menu', obj)[0]) {
		nConfig.addEvent(obj, 'mouseover', function() {
			obj.menu.style.display = 'block';
//			nMorpher.open(obj.menu);
		});
		nConfig.addEvent(obj, 'mouseout', function() {
			obj.menu.style.display = 'none';
//			nMorpher.close(obj.menu);
		});
	}
}
/* $$$ JS file: ajax/advAJAX.js: */
/*
 * AdvancedAJAX 1.1.2
 * (c) 2005-2006 Lukasz Lach
 *  mail: anakin@php5.pl
 *  www:  http://advajax.anakin.us/
 *        http://anakin.us/
 * http://creativecommons.org/licenses/LGPL/2.1/
 *
 */

function advAJAX() {

    var obj = new Object();

    obj.url = window.location.href;
    obj.method = "GET";
    obj.parameters = new Object();
    obj.jsonParameters = new Object();
    obj.headers = new Object();
    obj.async = true;
    obj.mimeType = "text/xml";
    obj.username = null;
    obj.password = null;
    obj.form = null;
    obj.disableForm = true;

    obj.unique = true;
    obj.uniqueParameter = "_uniqid";

    obj.requestDone = false;
    obj.queryString = "";
    obj.responseText = null;
    obj.responseXML = null;
    obj.status = null;
    obj.statusText = null;
    obj.aborted = false;
    obj.timeout = 0;
    obj.retryCount = 0;
    obj.retryDelay = 1000;
    obj.tag = null;
    obj.group = null;
    obj.progressTimerInterval = 50;

    obj.xmlHttpRequest = null;

    obj.onInitialization = null;
    obj.onFinalization = null;
    obj.onReadyStateChange = null;
    obj.onLoading = null;
    obj.onLoaded = null;
    obj.onInteractive = null;
    obj.onComplete = null;
    obj.onProgress = null;
    obj.onSuccess = null;
    obj.onFatalError = null;
    obj.onError = null;
    obj.onTimeout = null;
    obj.onRetryDelay = null;
    obj.onRetry = null;
    obj.onGroupEnter = null;
    obj.onGroupLeave = null;

    obj.createXmlHttpRequest = function() {

        if (typeof XMLHttpRequest != "undefined")
            return new XMLHttpRequest();
        var xhrVersion = [ "MSXML2.XMLHttp.5.0", "MSXML2.XMLHttp.4.0","MSXML2.XMLHttp.3.0",
                "MSXML2.XMLHttp","Microsoft.XMLHttp" ];
        for (var i = 0; i < xhrVersion.length; i++) {
            try {
                var xhrObj = new ActiveXObject(xhrVersion[i]);
                return xhrObj;
            } catch (e) { }
        }
        obj.raiseEvent("FatalError");
        return null;
    };

    obj._oldResponseLength = null;
    obj._progressTimer = null;
    obj._progressStarted = navigator.userAgent.indexOf('Opera') == -1;
    obj._onProgress = function() {

        if (typeof obj.onProgress == "function" &&
            typeof obj.xmlHttpRequest.getResponseHeader == "function") {
            var contentLength = obj.xmlHttpRequest.getResponseHeader("Content-length");
            if (contentLength != null && contentLength != '') {
                var responseLength = obj.xmlHttpRequest.responseText.length;
                if (responseLength != obj._oldResponseLength) {
                    obj.raiseEvent("Progress", obj, responseLength, contentLength);
                    obj._oldResponseLength = obj.xmlHttpRequest.responseText.length;
                }
            }
        }
        if (obj._progressStarted) return;
        obj._progressStarted = true;
        var _obj = this;
        this.__onProgress = function() {
            obj._onProgress();
            obj._progressTimer = window.setTimeout(_obj.__onProgress, obj.progressTimerInterval);
        }
        _obj.__onProgress();
    }

    obj._onInitializationHandled = false;
    obj._initObject = function() {

        if (obj.xmlHttpRequest != null) {
            delete obj.xmlHttpRequest["onreadystatechange"];
            obj.xmlHttpRequest = null;
        }
        if ((obj.xmlHttpRequest = obj.createXmlHttpRequest()) == null)
            return null;
        if (typeof obj.xmlHttpRequest.overrideMimeType != "undefined")
            obj.xmlHttpRequest.overrideMimeType(obj.mimeType);
        obj.xmlHttpRequest.onreadystatechange = function() {

            if (obj == null || obj.xmlHttpRequest == null)
                return;
            obj.raiseEvent("ReadyStateChange", obj, obj.xmlHttpRequest.readyState);
            obj._onProgress();
            switch (obj.xmlHttpRequest.readyState) {
                case 1: obj._onLoading(); break;
                case 2: obj._onLoaded(); break;
                case 3: obj._onInteractive(); break;
                case 4: obj._onComplete(); break;
            }
        };
        obj._onLoadingHandled =
            obj._onLoadedHandled =
            obj._onInteractiveHandled =
            obj._onCompleteHandled = false;
    };

    obj._onLoading = function() {

        if (obj._onLoadingHandled)
            return;
        if (!obj._retry && obj.group != null) {
            if (typeof advAJAX._groupData[obj.group] == "undefined")
                advAJAX._groupData[obj.group] = 0;
            advAJAX._groupData[obj.group]++;
            if (typeof obj.onGroupEnter == "function" && advAJAX._groupData[obj.group] == 1)
                obj.onGroupEnter(obj);
        }
        obj.raiseEvent("Loading", obj);
        obj._onLoadingHandled = true;
    };
    obj._onLoaded = function() {

        if (obj._onLoadedHandled)
            return;
        obj.raiseEvent("Loaded", obj);
        obj._onLoadedHandled = true;
    };
    obj._onInteractive = function() {

        if (obj._onInteractiveHandled)
            return;
        obj.raiseEvent("Interactive", obj);
        obj._onInteractiveHandled = true;
        if (!obj._progressStarted)
            obj._onProgress();
    };
    obj._onComplete = function() {

        if (obj._onCompleteHandled || obj.aborted)
            return;
        if (obj._progressStarted) {
            window.clearInterval(obj._progressTimer);
            obj._progressStarted = false;
        }
        obj.requestDone = true;
        with (obj.xmlHttpRequest) {
            obj.responseText = responseText;
            obj.responseXML = responseXML;
            if (typeof status != "undefined")
                obj.status = status;
            if (typeof statusText != "undefined")
                obj.statusText = statusText;
        }
        obj.raiseEvent("Complete", obj);
        obj._onCompleteHandled = true;
        if (obj.status == 200)
            obj.raiseEvent("Success", obj); else
            obj.raiseEvent("Error", obj);
        delete obj.xmlHttpRequest['onreadystatechange'];
        obj.xmlHttpRequest = null;
        if (obj.disableForm)
            obj.switchForm(true);
        obj._groupLeave();
        obj.raiseEvent("Finalization", obj);
    };

    obj._groupLeave = function() {

        if (obj.group != null) {
            advAJAX._groupData[obj.group]--;
            if (advAJAX._groupData[obj.group] == 0)
                obj.raiseEvent("GroupLeave", obj);
        }
    };

    obj._retry = false;
    obj._retryNo = 0;
    obj._onTimeout = function() {

        if (obj == null || obj.xmlHttpRequest == null || obj._onCompleteHandled)
            return;
        obj.aborted = true;
        obj.xmlHttpRequest.abort();
        obj.raiseEvent("Timeout", obj);
        obj._retry = true;
        if (obj._retryNo != obj.retryCount) {
            obj._initObject();
            if (obj.retryDelay > 0) {
                obj.raiseEvent("RetryDelay", obj);
                startTime = new Date().getTime();
                while (new Date().getTime() - startTime < obj.retryDelay);
            }
            obj._retryNo++;
            obj.raiseEvent("Retry", obj, obj._retryNo);
            obj.run();
        } else {
            delete obj.xmlHttpRequest["onreadystatechange"];
            obj.xmlHttpRequest = null;
            if (obj.disableForm)
                obj.switchForm(true);
            obj._groupLeave();
            obj.raiseEvent("Finalization", obj);
        }
    };

    obj.run = function() {

        obj._initObject();
        if (obj.xmlHttpRequest == null)
            return false;
        obj.aborted = false;
        if (!obj._onInitializationHandled) {
            obj.raiseEvent("Initialization", obj);
            obj._onInitializationHandled = true;
        }
        if (obj.method == "GET" && obj.unique)
            obj.parameters[encodeURIComponent(obj.uniqueParameter)] =
            new Date().getTime().toString().substr(5) + Math.floor(Math.random() * 100).toString();
        if (!obj._retry) {
            for (var a in obj.parameters) {
                if (obj.queryString.length > 0)
                    obj.queryString += "&";
                if (typeof obj.parameters[a] != "object")
                    obj.queryString += encodeURIComponent(a) + "=" + encodeURIComponent(obj.parameters[a]); else {
                    for (var i = 0; i < obj.parameters[a].length; i++)
                        obj.queryString += encodeURIComponent(a) + "=" + encodeURIComponent(obj.parameters[a][i]) + "&";
                    obj.queryString = obj.queryString.slice(0, -1);
                }
            }
            for (var a in obj.jsonParameters) {
                var useJson = typeof [].toJSONString == 'function';
                if (obj.queryString.length > 0)
                    obj.queryString += "&";
                obj.queryString += encodeURIComponent(a) + "=";
                if (useJson)
                    obj.queryString += encodeURIComponent(obj.jsonParameters[a].toJSONString()); else
                    obj.queryString += encodeURIComponent(obj.jsonParameters[a]);
            }
            if (obj.method == "GET" && obj.queryString.length > 0)
                obj.url += (obj.url.indexOf("?") != -1 ? "&" : "?") + obj.queryString;
        }
        if (obj.disableForm)
            obj.switchForm(false);
        try {
            obj.xmlHttpRequest.open(obj.method, obj.url, obj.async, obj.username || '', obj.password || '');
        } catch (e) {
            obj.raiseEvent("FatalError", obj, e);
            return;
        }
        if (obj.timeout > 0)
            setTimeout(obj._onTimeout, obj.timeout);
        if (typeof obj.xmlHttpRequest.setRequestHeader != "undefined")
            for (var a in obj.headers)
                obj.xmlHttpRequest.setRequestHeader(encodeURIComponent(a), encodeURIComponent(obj.headers[a]));
        if (obj.method == "POST" && typeof obj.xmlHttpRequest.setRequestHeader != "undefined") {
            obj.xmlHttpRequest.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
            obj.xmlHttpRequest.send(obj.queryString);
        } else if (obj.method == "GET")
            obj.xmlHttpRequest.send('');
    };

    obj.handleArguments = function(args) {

        if (typeof args.form == "object" && args.form != null) {
            obj.form = args.form;
            obj.appendForm();
        }
        for (a in args) {
            if (typeof obj[a] == "undefined")
                obj.parameters[a] = args[a]; else {
                if (a != "parameters" && a != "headers")
                    obj[a] = args[a]; else
                    for (b in args[a])
                        obj[a][b] = args[a][b];
            }
        }
        obj.method = obj.method.toUpperCase();
    };

    obj.switchForm = function(enable) {

        if (typeof obj.form != "object" || obj.form == null)
            return;
        with (obj.form)
            for (var nr = 0; nr < elements.length; nr++)
                if (!enable) {
                    if (elements[nr]["disabled"])
                        elements[nr]["_disabled"] = true; else
                        elements[nr]["disabled"] = "disabled";
                } else
                    if (typeof elements[nr]["_disabled"] == "undefined")
                        elements[nr].removeAttribute("disabled");
    };

    obj.appendForm = function() {

        with (obj.form) {
            obj.method = getAttribute("method").toUpperCase();
            obj.url = getAttribute("action");
            for (var nr = 0; nr < elements.length; nr++) {
                var e = elements[nr];
                if (e.disabled)
                    continue;
                switch (e.type) {
                    case "text":
                    case "password":
                    case "hidden":
                    case "textarea":
                        obj.addParameter(e.name, e.value);
                        break;
                    case "select-one":
                        if (e.selectedIndex >= 0)
                            obj.addParameter(e.name, e.options[e.selectedIndex].value);
                        break;
                    case "select-multiple":
                        for (var nr2 = 0; nr2 < e.options.length; nr2++)
                            if (e.options[nr2].selected)
                                obj.addParameter(e.name, e.options[nr2].value);
                        break;
                    case "checkbox":
                    case "radio":
                        if (e.checked)
                            obj.addParameter(e.name, e.value);
                        break;
                }
            }
        }
    };

    obj.addParameter = function(name, value) {
        if (typeof obj.parameters[name] == "undefined")
            obj.parameters[name] = value; else
        if (typeof obj.parameters[name] != "object")
            obj.parameters[name] = [ obj.parameters[name], value ]; else
        obj.parameters[name][obj.parameters[name].length] = value;
    };
    obj.delParameter = function(name) {

        delete obj.parameters[name];
    };
    obj.raiseEvent = function(name) {
        var args = [];
        for (var i = 1; i < arguments.length; i++)
            args.push(arguments[i]);
        if (typeof obj["on" + name] == "function")
            obj["on" + name].apply(null, args);
        if (name == "FatalError")
            obj.raiseEvent("Finalization", obj);
    }

    if (typeof advAJAX._defaultParameters != "undefined")
        obj.handleArguments(advAJAX._defaultParameters);
    return obj;
}

advAJAX.get = function(args) {

    return advAJAX.handleRequest("GET", args);
};

advAJAX.post = function(args) {

    return advAJAX.handleRequest("POST", args);
};

advAJAX.head = function(args) {

    return advAJAX.handleRequest("HEAD", args);
};

advAJAX.submit = function(form, args) {

    if (typeof args == "undefined" || args == null)
        return -1;
    if (typeof form != "object" || form == null)
        return -2;
    var request = new advAJAX();
    args["form"] = form;
    request.handleArguments(args);
    return request.run();
};

advAJAX.assign = function(form, args) {

    if (typeof args == "undefined" || args == null)
        return -1;
    if (typeof form != "object" || form == null)
        return -2;
    if (typeof form["onsubmit"] == "function")
        form["_onsubmit"] = form["onsubmit"];
    form["advajax_args"] = args;
    form["onsubmit"] = function() {
        if (typeof this["_onsubmit"] != "undefined" && this["_onsubmit"]() === false)
            return false;
        if (advAJAX.submit(this, this["advajax_args"]) == false)
            return true;
        return false;
    }
    return true;
};

advAJAX.download = function(targetObj, url) {

    if (typeof targetObj == "string")
        targetObj = document.getElementById(targetObj);
    if (!targetObj)
        return -1;
    advAJAX.get({
        url: url,
        onSuccess : function(obj) {
            targetObj.innerHTML = obj.responseText;
        }
    });
};

advAJAX.scan = function() {

    var obj = document.getElementsByTagName("a");
    for (var i = 0; i < obj.length;) {
        if (obj[i].getAttribute("rel") == "advancedajax" && obj[i].getAttribute("href") !== null) {
            var url = obj[i].getAttribute("href");
            var div = document.createElement("div");
            div.innerHTML = obj[i].innerHTML;
            div.className = obj[i].className;
            var parent = obj[i].parentNode;
            parent.insertBefore(div, obj[i]);
            parent.removeChild(obj[i]);
            advAJAX.download(div, url);
        } else i++;
    }
};

advAJAX.handleRequest = function(requestType, args) {

    if (typeof args == "undefined" || args == null)
        return -1;
    var request = new advAJAX();
    window.advajax_obj = request;
    request.method = requestType;
    request.handleArguments(args);
    return request.run();
};

advAJAX._defaultParameters = new Object();
advAJAX.setDefaultParameters = function(args) {

    advAJAX._defaultParameters = new Object();
    for (a in args)
        advAJAX._defaultParameters[a] = args[a];
};

advAJAX._groupData = new Object();
/* $$$ JS file: ajax/ajax.js: */
/**
 * AJAX support for ConfigLevel framework.
 * Based on Advanced AJAX by Anakin (reference url: http://advajax.anakin.us).
 *
 * Standard AJAX options:
 * 		capturePhpErrors = true
 * 		capturePhpInfos = true
 * 		onPhpError = null
 * 		evalScripts = true
 * 		loaderTo = null
 * 		update = null
 * 		method = post
 *		uploadImages = false
 *
 *		+ all options available in advAJAX
 */

function ajax() {
	
	var ajax = this;
	ajax.requestCounter = 0;
	
	ajax.request = function(url, options) {
		if (!options) options = new Object;
		options = rewriteOptions(url, options);
		return advAJAX.handleRequest(options.method, options);
	}

	function rewriteOptions(url, options) {
		if (!options) options = new Object;

		// Informuje, ze wywolanie zostalo wykonane przez AJAXa.
		options.ajaxCall = true;
		
		options.onCompletes = new Array;
		options.onSuccesses = new Array;
		
		options.url = url;
		options.requestId = ajax.requestCounter++;
		
		if (options.update) {
			if (typeof(options.update) == 'string') {
				options.update = $(options.update);
			}
			if (!options.update) {
				alert('No DOM element "' + options.update + '".');
			}
			options.update.expectingRequestId = options.requestId;
		}
		
		if (options.capturePhpMsgs) {
			options.capturePhpErrors = true;
			options.capturePhpInfos = true;
		}
		
		if (options.onPhpError) {
			options.capturePhpErrors = true;
		}
		
		if (options.capturePhpErrors) {
			options.onCompletes.push(function(request) {
				if (request.phpError = ajax.capturePhpErrors(request.responseText)) {
					if (options.onPhpError) {
						options.onPhpError(request);
					}
				}
			});
		}
		
		if (options.loaderTo) {
			if (options.loaderTo = (typeof(options.loaderTo) == 'string')? $(options.loaderTo) : options.loaderTo) {
				if (options.loaderTo.loaderObj) {
					ajax.removeLoaderObj(options.loaderTo);
				}
				options.loaderTo.loaderObj = document.createElement('div');
				options.loaderTo.insertBefore(options.loaderTo.loaderObj, options.loaderTo.firstChild);
				options.loaderTo.loaderObj.className = 'ajaxLoaderClock';
				
				options.onCompletes.push(function(request) {
					ajax.removeLoaderObj(options.loaderTo);
				});
			}
		}
		
		if (options.update) {
			options.onCompletes.push(function(request) {
				if (options.update.expectingRequestId != null && options.update.expectingRequestId <= options.requestId) {
					options.update.innerHTML = request.responseText;
//					options.ajaxUrl = options.url;
				}
			});
		}
		
		if (options.capturePhpInfos) {
			options.onSuccesses.push(function(request) {
				request.phpInfo = ajax.capturePhpInfos(request.responseText);
			});
		}
		
		if (options.method) {
			options.method.toUpperCase();
		} else {
			options.method = 'POST';
		}
		
		if (options.onComplete) {
			options.onCompletes.push(options.onComplete);
		}
		
		options.onComplete = function(request) {
			for (var i in options.onCompletes) {
				if (typeof(options.onCompletes[i]) == 'function') {
					options.onCompletes[i](request);
				}
			}
		}
		
		if (options.onSuccess) {
			options.onSuccesses.push(options.onSuccess);
		}
		
		if (options.evalScripts) {
			options.onSuccesses.push(function(request) {
				ajax.evalScripts(request.responseText);
			});
		}
		
		options.onSuccess = function(request) {
			if (!request.phpError) {
				for (var i in options.onSuccesses) {
					if (typeof(options.onSuccesses[i]) == 'function') {
						options.onSuccesses[i](request);
					}
				}
			}
		}
		
		return options;
	}


	ajax.removeLoaderObj = function(loaderContainer) {
		if (loaderContainer && loaderContainer.loaderObj) {
			if (loaderContainer.loaderObj.parentNode) {
				loaderContainer.loaderObj.style.backgroundImage = 'none';
				loaderContainer.removeChild(loaderContainer.loaderObj);
			}
			loaderContainer.loaderObj = null;
			loaderContainer = null;
		}
	}


	ajax.update = function(update, url, options) {
		if (!options) options = new Object;
		options.update = update;
		if (options.evalScripts == undefined) {
			options.evalScripts = true;
		}
		ajax.request(url, options);
		
		return false;
	}

	
	/* Wykonuje submit formularza.
	 * Wysyla go pod adres zawarty w jego atrybucie 'action'.
	 * Jesli zostanie podana opcja 'url', ten adres bedzie uzyty zamiast 'action'.
	 * @return false
	 */
	ajax.submit = function(formObj, options) {
		if (typeof(formObj) == 'string') {
			formObj = $(formObj);
		}

		if (typeof(formObj) == 'object') {
			if (!options) options = new Object;
			if (options.url) {
				options = rewriteOptions(options.url, options);
			} else {
				options = rewriteOptions(formObj.action, options);
			}
			
			if (!options.uploadImages) {
				advAJAX.submit(formObj, options);
			} else if (AIM && typeof(AIM) == 'object') {
				if (!options.url) options.url = formObj.action;
				ajax.overwriteFormOptions(formObj, options.url + ((options.url.indexOf('?') >= 0)? '&' : '?') + 'ajaxCall=1');
				if (AIM.submit(formObj, {
					onStart: options.onLoading,
					onComplete: function(response) {
						ajax.revertFormOptions(formObj);
						if (options.onComplete) {
							options.onComplete({responseText: response, status: 200});
						}
					}
				})) {
					return true;
				} else {
					ajax.revertFormOptions(formObj);
				}
			}
		}
		return false;
	}
	
	ajax.overwriteFormOptions = function(formObj, url) {
		formObj.originalAction = formObj.action;
		formObj.action = url;
		formObj.originalTarget = formObj.target;
	}
	
	ajax.revertFormOptions = function(formObj) {
		if (formObj.originalAction !== undefined) {
			formObj.action = formObj.originalAction;
			formObj.originalAction = undefined;
			formObj.target = formObj.originalTarget;
			formObj.originalTarget = undefined;
			return true;
		}
		return false;
	}
	
	
	ajax.capturePhpInfos = function(text) {
		return this.extract(/\<\!\-\-\s*ajaxReportedInfo:\s*/, /\s*\/ajaxReport\-\-\>/, text);
	}
	
	ajax.capturePhpErrors = function(text) {
		return this.extract(/\<\!\-\-\s*ajaxReportedError:\s*/, /\s*\/ajaxReport\-\-\>/, text);
	}
	
//		var errors = [];
//		var error_sources = text.split(/\<\!\-\-\s*ajaxReportedError:\s*/);
//		
//		var counter = 0;
//		for (var i=1; i < error_sources.length; i++)
//			errors[counter++] = error_sources[i].split(/\s*\/ajaxReport\-\-\>/)[0];
//		
//		if (errors.length) {
//			return errors;
//		} else {
//			return null;
//		}
	
	// @todo : dolaczyc do opcji.
	ajax.includeScripts = function(text) {
		var files = this.extract(/<script.*src=\"/, /\"[^>]*>/, text);
		for (i in files) {
			ajax.include(files[i]);
		}
	}
//		var files = [];
//		var file_sources = text.split(/<script.*src=\"/);
//		
//		var counter = 0;
//		for (var i=1; i < file_sources.length; i++)
//			files[counter++] = escape(file_sources[i].split(/\"[^>]*>/)[0]);
//		
//		for(i = 0; i < counter; i++)
//			ajax.include(files[i]);


	ajax.evalScripts = function(text) {	
		var scripts = this.extract(/<script.*?>/, /<\/script>/, text);

		for (i in scripts) {
			eval(scripts[i]);
		}
//		var scripts = [];
//		var script_sources = text.split(/<script.*?>/);
//		
//		counter = 0;
//		for (var i=1; i < script_sources.length; i++)
//			scripts[counter++] = script_sources[i].split(/<\/script>/)[0];
//		
//		for (i=0; i < counter; i++)
//			eval( scripts[i] );
	}

	ajax.extract = function(beginDelimiter, endDelimiter, subject) {
		var parts = [];
		var sources = subject.split(beginDelimiter);
		
		var counter = 0;
		for (var i=1; i < sources.length; i++)
			parts[counter++] = sources[i].split(endDelimiter)[0];
		
		if (parts.length) {
			return parts;
		} else {
			return null;
		}
	}
	
	
	ajax.initLinksHistory = function() {
		advHistory.create(function(query) {
			if (query.length) {
				query = query.split(':');
				if (query.length > 1) {
					ajax.update(query[1], query[0], {evalScripts: true, loaderTo: query[1]});
				} else {
					alert('No container.');
				}
			}
		});
	}

	ajax.include = function(url, options) {
		if (!options) options = {};
		options.method = 'post';
		options.onSuccess = function(request) {
			eval(request.responseText);
		}
		ajax.request(url, options);
	}
}

var ajax = new ajax();
/* $$$ JS file: init.js: */
function initColumnBars() {
	var nColumnBars;
	if (nColumnBars = $$('nColumnsBar', 'div')) {
		for (var i in nColumnBars) {
			nColumnsBar(nColumnBars[i], {
				arrowNext: $$$('nArrowNext', 'a', nColumnBars[i].parentNode)[0],
				arrowPrev: $$$('nArrowPrev', 'a', nColumnBars[i].parentNode)[0]
			});
		}
	}
}

function parametersTableFix(){
	var pC=jQuery("div#pageContent")
	var hpC = pC.height();
	var tableWrapper=pC.find("div#tableWrapper");
	var itemDetailsHeader=pC.find("div.itemDetailsHeader");
	tableWrapper.height(hpC);
}

function startColorBox(){
	var thickBoxy=jQuery("a.thickbox");
	//thickBoxy.colorbox({slideshow:true});
	thickBoxy.colorbox({maxWidth:"90%",maxHeight:"90%"});
	var aMailsToAccept=jQuery("#listMailsData a.cBx");
	if(aMailsToAccept){
		aMailsToAccept.each(function(index, domEle){
			jQuery(domEle).colorbox({maxWidth:"90%",maxHeight:"90%",initialWidth:"530px", inline:true, href:"#"+domEle.title, title:"Treść wiadomości"});
		});
	}
}

nConfig.onLoad(initColumnBars);
nConfig.onLoad(parametersTableFix);
nConfig.onLoad(startColorBox);